package com.honry.common;

/**
 * 领域模型层超类型，用于保证属性合法状态。
 * 用自封装(Self-Encapsulation)来验证属性。 自封装性要求无论以哪种方式访问数据，
 * 即使从对象内部访问数据都必须通过getter和setter方法。
 * @author machao
 *
 */
public class AssertionConcern {

    protected AssertionConcern() {
        super();
    }
    
    /**
     * 两个参数相等，不相等则抛出异常
     * @param arg1
     * @param arg2
     * @param aMessage
     */
    protected void assertArgumentEquals(Object arg1, Object arg2, String aMessage) {
        if (!arg1.equals(arg2)) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 参数为false,为true则抛出异常
     * @param aBoolean
     * @param aMessage
     */
    protected void assertArgumentFalse(boolean aBoolean, String aMessage) {
        if (aBoolean) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 参数最大长度，大于最大值则抛出异常
     * @param aString	字符串
     * @param aMaximum 	最大长度
     * @param aMessage 	异常消息
     */
    protected void assertArgumentLength(String aString, int aMaximum, String aMessage) {
        int length = aString.trim().length();
        if (length > aMaximum) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 参数长度区间，长度必须在最小长度和最大长度之间
     * @param aString	参数
     * @param aMinimum	最小值
     * @param aMaximum	最大值
     * @param aMessage	异常消息
     */
    protected void assertArgumentLength(String aString, int aMinimum, int aMaximum, String aMessage) {
        int length = aString.trim().length();
        if (length < aMinimum || length > aMaximum) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 参数不能为null或为空
     * @param aString	参数
     * @param aMessage	异常消息
     */
    protected void assertArgumentNotEmpty(String aString, String aMessage) {
        if (aString == null || aString.trim().isEmpty()) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 两个参数不相等，相等则抛出异常
     * @param arg1
     * @param arg2
     * @param aMessage
     */
    protected void assertArgumentNotEquals(Object arg1, Object arg2, String aMessage) {
        if (arg1.equals(arg2)) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 参数不能为null
     * @param anObject
     * @param aMessage
     */
    protected void assertArgumentNotNull(Object anObject, String aMessage) {
        if (anObject == null) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * double值区间，值必须在最小值和最大值之间。
     * @param aValue	要断言的参数
     * @param aMinimum	最小值
     * @param aMaximum	最大值
     * @param aMessage	异常消息
     */
    protected void assertArgumentRange(double aValue, double aMinimum, double aMaximum, String aMessage) {
        if (aValue < aMinimum || aValue > aMaximum) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * float值区间，值必须在最小值和最大值之间。
     * @param aValue	要断言的参数
     * @param aMinimum	最小值
     * @param aMaximum	最大值
     * @param aMessage	异常消息
     */
    protected void assertArgumentRange(float aValue, float aMinimum, float aMaximum, String aMessage) {
        if (aValue < aMinimum || aValue > aMaximum) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * int值区间，值必须在最小值和最大值之间。
     * @param aValue	要断言的参数
     * @param aMinimum	最小值
     * @param aMaximum	最大值
     * @param aMessage	异常消息
     */
    protected void assertArgumentRange(int aValue, int aMinimum, int aMaximum, String aMessage) {
        if (aValue < aMinimum || aValue > aMaximum) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * long值区间，值必须在最小值和最大值之间。
     * @param aValue	要断言的参数
     * @param aMinimum	最小值
     * @param aMaximum	最大值
     * @param aMessage	异常消息
     */
    protected void assertArgumentRange(long aValue, long aMinimum, long aMaximum, String aMessage) {
        if (aValue < aMinimum || aValue > aMaximum) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 参数为true,不能为false。
     * @param aBoolean
     * @param aMessage
     */
    protected void assertArgumentTrue(boolean aBoolean, String aMessage) {
        if (!aBoolean) {
            throw new IllegalArgumentException(aMessage);
        }
    }

    /**
     * 状态为False,不能为true
     * @param aBoolean
     * @param aMessage
     */
    protected void assertStateFalse(boolean aBoolean, String aMessage) {
        if (aBoolean) {
            throw new IllegalStateException(aMessage);
        }
    }

    /**
     * 状态为true,不能为false
     * @param aBoolean
     * @param aMessage
     */
    protected void assertStateTrue(boolean aBoolean, String aMessage) {
        if (!aBoolean) {
            throw new IllegalStateException(aMessage);
        }
    }
}

